package com.ruoyi.doctor.service.impl;

import java.util.List;
import java.util.stream.Collectors;

import com.ruoyi.common.domain.doctor.Patient;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.stereotype.Service;
import com.ruoyi.doctor.mapper.DoctorMapper;
import com.ruoyi.common.domain.doctor.Doctor;
import com.ruoyi.doctor.service.IDoctorService;

import javax.annotation.Resource;

/**
 * 医生信息管理Service业务层处理
 * 
 * @author ruoyi
 * @date 2025-08-12
 */
@Service
public class DoctorServiceImpl implements IDoctorService 
{
    @Autowired
    private DoctorMapper doctorMapper;
    @Resource
    private RedisTemplate<String, Object> redisTemplate;

    @Override
    public Doctor selectDoctorByIdWithRealTimeFollow(Long id) {
        // 1. 从数据库查询医生基础信息（包括 del=0 的过滤）
        Doctor doctor = doctorMapper.selectDoctorById(id);

        if (doctor == null) {
            return null;
        }

        // 2. 从 Redis 获取该医生的实时关注量
        String redisKey = "doctor:follow:count:" + id;
        Object value = redisTemplate.opsForValue().get(redisKey); // 先拿到 Object

        Long realTimeFollowCount = null;
        if (value instanceof Number) {
            // ✅ 安全做法：如果是数字类型（Integer 或 Long），都统一用 .longValue() 转成 Long
            realTimeFollowCount = ((Number) value).longValue();
        } else if (value != null) {
            // 可选：如果 value 不是数字，比如是字符串，可以打印日志或者忽略
            // System.out.println("Redis 中的关注量不是数字类型，key=" + redisKey + ", value=" + value);
        }

        // 3. 如果 Redis 中有，则使用 Redis 的值；否则降级使用数据库中的 followCount
        if (realTimeFollowCount != null) {
            doctor.setFollowCount(realTimeFollowCount);
        }
        // 如果 Redis 中没有，则 doctor.setFollowCount(数据库原值) —— 已在查询中设置

        return doctor;
    }

    // 新增方法：查询医生列表，并为每个医生设置实时关注量
    @Override
    public List<Doctor> selectDoctorListWithRealTimeFollow(Doctor doctorQuery) {
        // 1. 先查数据库医生列表
        List<Doctor> doctorList = doctorMapper.selectDoctorList(doctorQuery);
        if (doctorList == null || doctorList.isEmpty()) {
            return doctorList;
        }

        // 2. 提取所有医生ID
        List<Long> doctorIds = doctorList.stream()
                .map(Doctor::getId)
                .collect(Collectors.toList());

        // 3. 遍历医生，逐个查询 Redis 中的实时关注量并设置
        for (Doctor doctor : doctorList) {
            String redisKey = "doctor:follow:count:" + doctor.getId();
            Object value = redisTemplate.opsForValue().get(redisKey);
            Long realTimeCount = null;

            if (value instanceof Number) {
                realTimeCount = ((Number) value).longValue(); // 安全转为 Long
            } else if (value != null) {
                // 可选：记录日志，关注量不是数字
                // log.warn("Redis 中 key={} 的关注量不是数字类型，value={}", redisKey, value);
            }
            if (realTimeCount != null) {
                doctor.setFollowCount(realTimeCount);
            }
            // 若 Redis 中无，则保持原数据库值
        }

        return doctorList;
    }

    /**
     * 查询医生信息管理
     * 
     * @param id 医生信息管理主键
     * @return 医生信息管理
     */
    @Override
    public Doctor selectDoctorById(Long id)
    {
        return doctorMapper.selectDoctorById(id);
    }

    @Override
    public List<Doctor> selectDoctor() {
        List<Doctor> doctors = doctorMapper.selectDoctor();
        return doctors;
    }

    @Override
    public Long getDoctorIdByUserId(Long userId) {
        Doctor doctor = doctorMapper.selectByUserId(userId);
        if (doctor != null) {
            return doctor.getId();
        }
        return null; // 如果没有找到对应的 patient 记录，返回 null
    }

    /**
     * 查询医生信息管理列表
     * 
     * @param doctor 医生信息管理
     * @return 医生信息管理
     */
    @Override
    public List<Doctor> selectDoctorList(Doctor doctor)
    {
        return doctorMapper.selectDoctorList(doctor);
    }



    /**
     * 新增医生信息管理
     * 
     * @param doctor 医生信息管理
     * @return 结果
     */
    @Override
    public int insertDoctor(Doctor doctor)
    {
        return doctorMapper.insertDoctor(doctor);
    }

    /**
     * 修改医生信息管理
     * 
     * @param doctor 医生信息管理
     * @return 结果
     */
    @Override
    public int updateDoctor(Doctor doctor)
    {
        return doctorMapper.updateDoctor(doctor);
    }

    /**
     * 批量删除医生信息管理
     * 
     * @param ids 需要删除的医生信息管理主键
     * @return 结果
     */
    @Override
    public int deleteDoctorByIds(Long[] ids)
    {
        return doctorMapper.deleteDoctorByIds(ids);
    }

    /**
     * 删除医生信息管理信息
     * 
     * @param id 医生信息管理主键
     * @return 结果
     */
    @Override
    public int deleteDoctorById(Long id)
    {
        return doctorMapper.deleteDoctorById(id);
    }
}
